package com.zhenmaitang.clinic_sys.service.impl;

import com.zhenmaitang.clinic_sys.entity.DataScope;
import com.zhenmaitang.clinic_sys.entity.RoleDataScope;
import com.zhenmaitang.clinic_sys.entity.User;
import com.zhenmaitang.clinic_sys.mapper.DataScopeMapper;
import com.zhenmaitang.clinic_sys.mapper.RoleDataScopeMapper;
import com.zhenmaitang.clinic_sys.service.DataScopeService;
import com.zhenmaitang.clinic_sys.service.UserService;
import com.zhenmaitang.clinic_sys.service.RoleService;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * 数据权限服务实现类
 */
@Service
public class DataScopeServiceImpl implements DataScopeService {

    @Autowired
    private DataScopeMapper dataScopeMapper;
    
    @Autowired
    private RoleDataScopeMapper roleDataScopeMapper;
    
    @Autowired
    private UserService userService;
    
    
    @Autowired
    private RoleService roleService;

    @Override
    public List<DataScope> getAllDataScopes() {
        return dataScopeMapper.findAll();
    }

    @Override
    public DataScope getDataScopeById(Integer id) {
        return dataScopeMapper.findById(id);
    }

    @Override
    public DataScope getDataScopeByCode(String code) {
        return dataScopeMapper.findByCode(code);
    }

    @Override
    public DataScope createDataScope(DataScope dataScope) {
        dataScope.setCreateTime(LocalDateTime.now());
        dataScope.setUpdateTime(LocalDateTime.now());
        dataScopeMapper.insert(dataScope);
        return dataScope;
    }

    @Override
    public DataScope updateDataScope(DataScope dataScope) {
        dataScope.setUpdateTime(LocalDateTime.now());
        dataScopeMapper.update(dataScope);
        return dataScope;
    }

    @Override
    public void deleteDataScope(Integer id) {
        dataScopeMapper.deleteById(id);
    }

    @Override
    public void assignDataScopeToRole(RoleDataScope roleDataScope) {
        // 先删除已有的数据权限关联
        roleDataScopeMapper.deleteByRoleIdAndResource(roleDataScope.getRoleId(), 
                getDataScopeById(roleDataScope.getDataScopeId()).getResource());
        
        // 添加新的数据权限关联
        roleDataScopeMapper.insert(roleDataScope);
    }

    @Override
    public List<RoleDataScope> getDataScopesByRoleId(Integer roleId) {
        return roleDataScopeMapper.findByRoleId(roleId);
    }

    @Override
    public List<DataScope> getUserDataScopes(Integer userId, String resource) {
        User user = userService.findById(userId);
        if (user == null || !user.getEnabled() || user.getRole() == null || user.getRole().isEmpty()) {
            return new ArrayList<>();
        }
        
        Set<DataScope> dataScopes = new HashSet<>();
        
        // 处理用户的所有角色
        for (String roleName : user.getRole()) {
            try {
                Integer roleId = roleService.getRoleByName(roleName).getId();
                
                // 获取角色的数据权限
                List<RoleDataScope> roleDataScopes = roleDataScopeMapper.findByRoleIdAndResource(roleId, resource);
                
                // 添加到结果集
                for (RoleDataScope rds : roleDataScopes) {
                    dataScopes.add(dataScopeMapper.findById(rds.getDataScopeId()));
                }
            } catch (Exception e) {
                // 如果角色不存在，跳过该角色
                continue;
            }
        }
        
        return new ArrayList<>(dataScopes);
    }

    @Override
    public boolean hasDataPermission(Integer userId, String resource, Integer dataId) {
        // 获取用户的数据范围
        List<Integer> dataScope = getUserDataScope(userId, resource);
        
        // 如果返回null，表示有全部权限
        if (dataScope == null) {
            return true;
        }
        
        // 检查数据ID是否在用户的数据范围内
        return dataScope.contains(dataId);
    }

    @Override
    public List<Integer> getUserDataScope(Integer userId, String resource) {
        User user = userService.findById(userId);
        if (user == null || !user.getEnabled() || user.getRole() == null || user.getRole().isEmpty()) {
            return new ArrayList<>();
        }
        
        // 遍历用户的所有角色，寻找最高权限
        for (String roleName : user.getRole()) {
            try {
                Integer roleId = roleService.getRoleByName(roleName).getId();
                
                // 获取角色的数据权限
                List<RoleDataScope> roleDataScopes = roleDataScopeMapper.findByRoleIdAndResource(roleId, resource);
                
                // 处理数据权限
                for (RoleDataScope roleDataScope : roleDataScopes) {
                    DataScope dataScope = dataScopeMapper.findById(roleDataScope.getDataScopeId());
                    
                    // 根据数据权限类型处理
                    switch (dataScope.getType()) {
                        case "ALL":
                            // 全部数据权限
                            return null; // 返回null表示有全部权限
                        case "DEPARTMENT":
                            // 部门数据权限
                            return dataScopeMapper.findDepartmentIdsByUserId(userId);
                        case "PERSONAL":
                            // 个人数据权限
                            List<Integer> personalScope = new ArrayList<>();
                            personalScope.add(userId);
                            return personalScope;
                        default:
                            // 其他类型的权限，返回空列表
                            return new ArrayList<>();
                    }
                }
            } catch (Exception e) {
                // 如果角色不存在，跳过该角色
                continue;
            }
        }
        
        // 如果没有找到任何权限配置，默认没有权限
        return new ArrayList<>();
    }
    
    /**
     * 获取部门相关的数据ID列表
     */
    private List<Integer> getDepartmentDataIds(Integer departmentId, String resource) {
        if (departmentId == null) {
            return new ArrayList<>();
        }
        
        // 根据资源类型获取相应的数据ID列表
        switch (resource) {
            case "USER":
                // 获取部门下的所有用户ID
                return userService.findUsersByDepartment(departmentId).stream()
                        .map(User::getId)
                        .collect(Collectors.toList());
                
            case "DEPARTMENT":
                // 只能查看自己所在的部门
                List<Integer> deptIds = new ArrayList<>();
                deptIds.add(departmentId);
                return deptIds;
                
            // 可以根据需要添加其他资源类型的处理
            default:
                return new ArrayList<>();
        }
    }
    
    /**
     * 获取用户自己相关的数据ID列表
     */
    private List<Integer> getSelfDataIds(Integer userId, String resource) {
        // 根据资源类型获取相应的数据ID列表
        switch (resource) {
            case "USER":
                // 只能查看自己的用户信息
                List<Integer> userIds = new ArrayList<>();
                userIds.add(userId);
                return userIds;
                
            // 可以根据需要添加其他资源类型的处理
            default:
                return new ArrayList<>();
        }
    }
    
    /**
     * 获取自定义范围的数据ID列表
     */
    private List<Integer> getCustomDataIds(String customScope, String resource) {
        // 解析自定义范围（JSON格式）并返回相应的数据ID列表
        // 这里需要根据实际业务逻辑实现
        // 简单示例：假设customScope是逗号分隔的ID列表
        if (customScope == null || customScope.isEmpty()) {
            return new ArrayList<>();
        }
        
        String[] ids = customScope.split(",");
        List<Integer> dataIds = new ArrayList<>();
        for (String id : ids) {
            try {
                dataIds.add(Integer.parseInt(id.trim()));
            } catch (NumberFormatException e) {
                // 忽略非数字ID
            }
        }
        
        return dataIds;
    }
}